package com.siss.tenancy.user.utils;

import com.alibaba.druid.util.StringUtils;

import java.util.ArrayList;
import java.util.List;
import java.util.Vector;


/**
 * <p>类名: ArraysUtil</p>
 * <p>描述:TODO</p>
 * <p>创建人: liyp</p>
 * <p>创建时间: 2019/10/26 15:31</p>
 * <p>@version 2.0  </p>
 * <p>修改内容: ......</p>
 * <p>修改说明: ......</p>
 * <p>修改时间: ......</p>
 * <p>修改人: ......</p>
 * <p>每次修改，请增加上述修改信息说明</>
 */

public class ArraysUtil {

    public static void main(String[] args) {
        String a = "a,b,c";
        List<List<String>> list = getAllComposeByString(a,",");
        List<String> listStr = null;
        List<String> result = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            result.add(listToString1(list.get(i)));
        }
        for (String s : result) {
            System.out.println(s);
        }
    }


    /**
     *
     * 功能描述：将list的元素用逗号拼接
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:03
     * 参数: [list]
     *  返回值： java.lang.String
     */
    public static String listToString1(List<String> list) {
        StringBuilder sb = new StringBuilder();
        if (list != null && list.size() > 0) {
            for (int i = 0; i < list.size(); i++) {
                if (i < list.size() - 1) {
                    sb.append(list.get(i) + ",");
                } else {
                    sb.append(list.get(i));
                }
            }
        }
        return sb.toString();
    }

    /**
     *
     * 功能描述：获取list元素的组合集合后，将组合集合元素用逗号拼接返回一个新集合
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:03
     * 参数: [listStr]
     *  返回值： java.util.List<java.lang.String>
     */
    public static List<String> getListByseparation(List<String> listStr){
        List<String> result = new ArrayList<>();
        List<List<String>> list = getAllComposeByStringList(listStr);
        for (int i = 0; i < list.size(); i++) {
            result.add(listToString1(list.get(i)));
        }
        return result;
    }

    /**
     *
     * 功能描述：将字符串根据分隔符转换成集合后，获取集合元素中的组合集合，返回一个组合集合后的新集合 ，例如：{1,2} 返回1；2；1,2三个是集合的元素
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:04
     * 参数: [str, separation]
     *  返回值： java.util.List<java.util.List<java.lang.String>>
     */
    public static List<List<String>> getAllComposeByString(String str,String separation){
        if(StringUtils.isEmpty(str)){
            return new ArrayList<>();
        }
        String[] arrays = str.split(separation);
        List<String> listStr = getListByArray(arrays);
        List<List<String>> result = new ArrayList<>();
        for (int i = 1; i <= listStr.size(); i++) {
            result.addAll(startCompose(listStr,i));
        }
        return result;
    }

    /**
     *
     * 功能描述：将集合中的元素任意组合成新集合，新集合作为元素，返回一个以组合为元素的新集合
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:06
     * 参数: [list]
     *  返回值： java.util.List<java.util.List<java.lang.String>>
     */
    public static List<List<String>> getAllComposeByStringList(List<String> list){
        List<List<String>> result = new ArrayList<>();
        for (int i = 1; i <= list.size(); i++) {
            result.addAll(startCompose(list,i));
        }
        return result;
    }

    /**
     *
     * 功能描述：将一个泛型数组分隔，返回一个数组元素任意组合的新集合
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:07
     * 参数: [arrays]
     *  返回值： java.util.List<java.util.List<T>>
     */
    public static <T> List<List<T>> getAllComposeByArrays(T[] arrays){
        List<List<T>> result = new ArrayList<>();
        List<T> listT = getListByArray(arrays);
        for (int i = 1; i <= listT.size(); i++) {
            result.addAll(startCompose(listT,i));
        }
        return result;
    }

    /**
     *
     * 功能描述：执行入口
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:08
     * 参数: [list, size]
     *  返回值： java.util.List<java.util.List<T>>
     */
    public static <T> List<List<T>> startCompose(List<T> list,int size){
        Vector<List<T>> v = new Vector<>();
        Vector<T> vv = new Vector<>();
        pro(list,0,size,vv,v);
        List<List<T>> returnList = new ArrayList<>(v);
        return returnList;
    }

    /**
     *
     * 功能描述：将泛型数组转为集合
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:09
     * 参数: [arrays]
     *  返回值： java.util.List<T>
     */
    public static <T> List<T> getListByArray(T [] arrays){
        List<T> list = new ArrayList<>(arrays.length);
        for (T array : arrays) {
            list.add(array);
        }
        return list;
    }

    /**
     *
     * 功能描述：递归组合方法
     * 作   者： liyp
     * 创建时间： 2019/10/26 19:09
     * 参数: [a, start, n, vv, v]
     *  返回值： void
     */
    public static <T> void pro(List<T> a, int start, int n,Vector<T> vv,Vector<List<T>> v) {
        if (n == 0) {
            List<T> list = new ArrayList<>(vv.size());
            for (int i = 0; i < vv.size(); i++) {
                list.add(vv.get(i));
            }
            v.add(list);
            return;
        }
        if (start >= a.size()) {
            return;
        }
        for (int i = start; i < a.size(); i++) {
            vv.add(a.get(i));
            pro(a, i + 1, n - 1,vv,v);
            vv.remove(vv.size()-1);
        }
    }

}
